// 智能内容填写工具 - 抖音发布流程（基于真实HTML）
class ContentFiller {
  constructor() {
    this.isInitialized = false;
    this.delayTime = 0;
    this.publishTime = null
  }

  // 初始化 ContentFiller
  async init () {
    if (this.isInitialized) {
      return;
    }

    try {
      // 等待页面加载完成
      await this.waitForPageLoad();

      // 注入必要的样式和脚本
      this.injectStyles();

      this.isInitialized = true;
      console.log('ContentFiller 初始化完成');
    } catch (error) {
      console.error('ContentFiller 初始化失败:', error);
    }
  }

  // 等待页面加载完成
  async waitForPageLoad () {
    return new Promise((resolve) => {
      if (document.readyState === 'complete') {
        resolve();
      } else {
        window.addEventListener('load', resolve);
      }
    });
  }

  // 注入样式
  injectStyles () {
    const style = document.createElement('style');
    style.textContent = `
      .content-filler-highlight {
        background-color: #ffeb3b !important;
        border: 2px solid #ff9800 !important;
        box-shadow: 0 0 10px rgba(255, 152, 0, 0.5) !important;
      }
      
      .content-filler-status {
        position: fixed;
        top: 20px;
        right: 20px;
        background: #4caf50;
        color: white;
        padding: 10px 20px;
        border-radius: 5px;
        z-index: 10000;
        font-family: Arial, sans-serif;
        font-size: 14px;
        max-width: 300px;
        word-wrap: break-word;
      }
      
      .content-filler-delay {
        position: fixed;
        top: 60px;
        right: 20px;
        background: #2196f3;
        color: white;
        padding: 8px 16px;
        border-radius: 5px;
        z-index: 10000;
        font-family: Arial, sans-serif;
        font-size: 12px;
      }
    `;
    document.head.appendChild(style);
  }

  // 显示状态信息
  showStatus (message, duration = 3000) {
    const status = document.createElement('div');
    status.className = 'content-filler-status';
    status.textContent = message;
    document.body.appendChild(status);

    setTimeout(() => {
      if (status.parentNode) {
        status.parentNode.removeChild(status);
      }
    }, duration);
  }

  // 显示延迟时间
  showDelay (message, duration = 2000) {
    const delay = document.createElement('div');
    delay.className = 'content-filler-delay';
    delay.textContent = message;
    document.body.appendChild(delay);

    setTimeout(() => {
      if (delay.parentNode) {
        delay.parentNode.removeChild(delay);
      }
    }, duration);
  }

  // 智能等待元素出现
  async waitForElement (selectors, timeout = 20000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      // 尝试所有选择器
      for (const selector of selectors) {
        try {
          const element = document.querySelector(selector);
          if (element) {
            console.log(`✅ 找到元素: ${selector}`);
            return element;
          }
        } catch (error) {
          // 忽略选择器错误
        }
      }

      // 如果选择器都失败，尝试智能查找
      try {
        // 智能查找策略
        const smartElement = this.findElementSmartly(selectors);
        if (smartElement) {
          console.log('✅ 通过智能查找找到元素');
          return smartElement;
        }
      } catch (error) {
        // 忽略智能查找错误
      }

      // 显示等待状态
      this.showDelay(3);
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    throw new Error(`元素在 ${timeout}ms 内未找到，尝试的选择器: ${selectors.join(', ')}`);
  }

  // 智能查找元素（处理动态class名）
  findElementSmartly (selectors) {
    // 分析选择器类型，使用相应的查找策略
    for (const selector of selectors) {
      try {
        // 如果选择器包含class名，尝试模糊匹配
        if (selector.includes('.')) {
          const className = selector.split('.')[1];
          if (className) {
            // 查找包含该class名的元素
            const elements = document.querySelectorAll(`[class*="${className}"]`);
            if (elements.length > 0) {
              console.log(`✅ 通过模糊class匹配找到元素: ${className}`);
              return elements[0];
            }
          }
        }

        // 如果选择器包含ID，直接查找
        if (selector.includes('#')) {
          const element = document.querySelector(selector);
          if (element) {
            return element;
          }
        }

        // 如果选择器包含属性，尝试查找
        if (selector.includes('[') && selector.includes(']')) {
          const element = document.querySelector(selector);
          if (element) {
            return element;
          }
        }

      } catch (error) {
        // 忽略单个选择器的错误
      }
    }

    return null;
  }

  // 通过文本内容查找元素
  findElementByText (container, text) {
    const walker = document.createTreeWalker(
      container,
      NodeFilter.SHOW_ELEMENT,
      null,
      false
    );

    let node;
    while (node = walker.nextNode()) {
      if (node.textContent && node.textContent.includes(text)) {
        return node;
      }
    }

    return null;
  }

  // 等待多个元素出现
  async waitForElements (selectors, timeout = 10000) {
    const startTime = Date.now();
    const elements = {};

    while (Date.now() - startTime < timeout) {
      let allFound = true;

      for (const [key, selector] of Object.entries(selectors)) {
        const element = document.querySelector(selector);
        if (element) {
          elements[key] = element;
        } else {
          allFound = false;
        }
      }

      if (allFound) {
        return elements;
      }

      await new Promise(resolve => setTimeout(resolve, 100));
    }

    throw new Error(`部分元素在 ${timeout}ms 内未找到`);
  }

  // 查找包含特定文本的元素
  findElementByText (selector, text) {
    const elements = document.querySelectorAll(selector);
    for (const element of elements) {
      if (element.textContent && element.textContent.includes(text)) {
        return element;
      }
    }
    return null;
  }

  // 显示延时状态
  showDelay (seconds) {
    this.showStatus(`⏳ 等待 ${seconds} 秒...`);
  }

  // 延时等待
  async delay (seconds) {
    console.log(`⏳ 等待 ${seconds} 秒...`);
    this.showDelay(seconds);
    await new Promise(resolve => setTimeout(resolve, seconds * 1000));
  }

  // 点击高清发布按钮
  async clickHighDefinitionPublish () {
    try {
      console.log('🎯 第一步：点击左侧的高清发布按钮');
      this.showStatus('🎯 点击高清发布按钮...');

      // 等待3秒后开始操作
      await this.delay(3);

      // 使用多种策略查找高清发布按钮
      let publishButton = null;

      // 策略1：通过ID查找
      try {
        publishButton = document.querySelector('#douyin-creator-master-side-upload-wrap button');
        if (publishButton) {
          console.log('✅ 通过ID找到发布按钮');
        }
      } catch (e) {
        console.log('⚠️ ID查找失败，尝试其他方法');
      }

      // 策略2：通过文本内容查找
      if (!publishButton) {
        try {
          const allButtons = document.querySelectorAll('button');
          for (const button of allButtons) {
            const buttonText = button.textContent || button.innerText || '';
            if (buttonText.includes('高清发布') || buttonText.includes('发布视频') || buttonText.includes('发布')) {
              publishButton = button;
              console.log('✅ 通过文本内容找到发布按钮:', buttonText);
              break;
            }
          }
        } catch (e) {
          console.log('⚠️ 文本查找失败，尝试其他方法');
        }
      }

      // 策略3：通过属性查找
      if (!publishButton) {
        try {
          publishButton = document.querySelector('button[aria-describedby*="mhvg8rb"]') ||
            document.querySelector('button.douyin-creator-master-button-primary') ||
            document.querySelector('button[type="button"]');
          if (publishButton) {
            console.log('✅ 通过属性找到发布按钮');
          }
        } catch (e) {
          console.log('⚠️ 属性查找失败，尝试其他方法');
        }
      }

      // 策略4：通过位置和样式查找（左侧导航栏的第一个按钮）
      if (!publishButton) {
        try {
          const sidebar = document.querySelector('aside') || document.querySelector('.sider') || document.querySelector('[class*="sider"]');
          if (sidebar) {
            const firstButton = sidebar.querySelector('button');
            if (firstButton) {
              publishButton = firstButton;
              console.log('✅ 通过位置找到发布按钮（左侧第一个按钮）');
            }
          }
        } catch (e) {
          console.log('⚠️ 位置查找失败');
        }
      }

      if (!publishButton) {
        throw new Error('未找到高清发布按钮，尝试了多种查找策略');
      }

      console.log('✅ 找到发布按钮，准备点击');
      publishButton.classList.add('content-filler-highlight');

      // 延时2秒后点击
      await this.delay(2);
      publishButton.click();
      console.log('✅ 已点击发布视频按钮');

      // 点击后等待5秒让页面加载
      await this.delay(5);

      publishButton.classList.remove('content-filler-highlight');
      this.showStatus('✅ 高清发布按钮点击完成');

      return true;
    } catch (error) {
      console.error('点击高清发布按钮失败:', error);
      this.showStatus('❌ 点击高清发布按钮失败');
      return false;
    }
  }

  // 填写标题
  async fillTitle (title) {
    try {
      console.log('📝 填写标题:', title);
      this.showStatus('📝 填写标题...');

      // 等待3秒后开始填写
      await this.delay(3);

      // 使用实际存在的选择器，支持富文本编辑器和普通输入框
      const titleInput = await this.waitForElement([
        // 优先查找抖音特有的input元素
        'input.semi-input.semi-input-default[placeholder*="标题"]',
        'input.semi-input[placeholder*="标题"]',
        'input[placeholder="添加作品标题"]',
        'input[placeholder*="作品标题"]',
        'input[placeholder*="标题"]',
        'input[placeholder*="title"]',
        // 富文本编辑器
        'div[data-placeholder*="标题"]',
        'div[data-placeholder*="title"]',
        'div[data-placeholder*="作品标题"]',
        'div[data-placeholder*="视频标题"]',
        'div[contenteditable="true"][data-placeholder*="标题"]',
        'div[data-slate-editor="true"][data-placeholder*="标题"]',
        'div.editor-kit-container[data-placeholder*="标题"]',
        // 通用选择器
        'input[type="text"]',
        '.title-input',
        '[data-testid="title-input"]'
      ]);

      titleInput.classList.add('content-filler-highlight');

      // 延时2秒后开始输入
      await this.delay(2);

      // 清空输入框 - 确保完全清空
      if (titleInput.contentEditable === 'true') {
        titleInput.innerHTML = '';
        titleInput.textContent = '';
      } else {
        titleInput.value = '';
      }

      // 延时1秒后输入内容
      await this.delay(1);

      // 根据元素类型设置内容
      if (titleInput.contentEditable === 'true') {
        // 富文本编辑器
        titleInput.textContent = title;
      } else if (titleInput.tagName === 'INPUT') {
        // 普通input元素 - 使用模拟用户输入的方式
        console.log('📝 使用模拟用户输入方式设置标题:', title);
        console.log('📝 input类型:', titleInput.type);
        console.log('📝 input class:', titleInput.className);

        try {
          // 方法1：使用Object.defineProperty强制设置
          console.log('🔄 尝试方法1：Object.defineProperty强制设置...');

          // 聚焦到输入框
          titleInput.focus();
          await this.delay(0.5);

          // 选中所有内容
          titleInput.select();
          await this.delay(0.5);

          // 清空内容 - 使用多种方法
          titleInput.value = '';
          titleInput.defaultValue = '';
          titleInput.removeAttribute('value');
          await this.delay(0.5);

          // 强制设置value属性
          Object.defineProperty(titleInput, 'value', {
            value: title,
            writable: true,
            configurable: true
          });

          // 同时设置其他属性
          titleInput.defaultValue = title;
          titleInput.setAttribute('value', title);
          titleInput.dataset.value = title;

          console.log('✅ 使用Object.defineProperty强制设置成功');

        } catch (e) {
          console.log('❌ Object.defineProperty失败:', e.message);
          return false;
        }

        // 等待一下让页面响应
        await this.delay(1);

        // 最终验证：检查所有可能的属性
        console.log('🔍 最终验证标题设置结果:');
        console.log('📝 期望值:', title);
        console.log('📝 input.value:', titleInput.value);
        console.log('📝 input.defaultValue:', titleInput.defaultValue);
        console.log('📝 input.getAttribute("value"):', titleInput.getAttribute('value'));
        console.log('📝 input.dataset.value:', titleInput.dataset.value);

        // 最终验证：检查所有可能的属性
        console.log('🔍 最终验证标题设置结果:');
        console.log('📝 期望值:', title);
        console.log('📝 input.value:', titleInput.value);
        console.log('📝 input.defaultValue:', titleInput.defaultValue);
        console.log('📝 input.getAttribute("value"):', titleInput.getAttribute('value'));
        console.log('📝 input.dataset.value:', titleInput.dataset.value);

      } else {
        // 其他类型元素
        titleInput.value = title;
      }

      // 触发输入事件
      titleInput.dispatchEvent(new Event('input', { bubbles: true }));
      titleInput.dispatchEvent(new Event('change', { bubbles: true }));

      // 验证内容是否设置成功
      await this.delay(1);
      const actualValue = titleInput.contentEditable === 'true' ? titleInput.textContent : titleInput.value;
      console.log('📝 验证标题设置结果:');
      console.log('📝 期望值:', title);
      console.log('📝 实际值:', actualValue);
      console.log('📝 设置成功:', actualValue === title);

      // 输入完成后等待2秒
      await this.delay(2);

      titleInput.classList.remove('content-filler-highlight');
      this.showStatus('✅ 标题填写完成');

      return true;
    } catch (error) {
      console.error('填写标题失败:', error);
      this.showStatus('❌ 填写标题失败');
      return false;
    }
  }

  // 填写内容
  async fillContent (content) {
    try {
      console.log('📝 填写内容:', content);
      this.showStatus('📝 填写内容...');

      // 等待3秒后开始填写
      await this.delay(3);

      // 使用实际存在的选择器
      const contentInput = await this.waitForElement([
        'div[data-placeholder*="作品简介"]',
        'div[data-placeholder*="简介"]',
        'div[data-placeholder*="描述"]',
        'div[data-placeholder*="内容"]',
        'div[contenteditable="true"][data-placeholder]',
        'div[data-slate-editor="true"]',
        'div.editor-kit-container',
        'div[contenteditable="true"]'
      ]);

      contentInput.classList.add('content-filler-highlight');

      // 延时2秒后开始输入
      await this.delay(2);

      // 清空输入框 - 确保完全清空
      contentInput.innerHTML = '';
      contentInput.textContent = '';

      // 延时1秒后输入内容
      await this.delay(1);

      // 一次性设置内容，避免重复
      if (contentInput.contentEditable === 'true') {
        contentInput.textContent = content;
      } else {
        contentInput.value = content;
      }

      // 触发输入事件
      contentInput.dispatchEvent(new Event('input', { bubbles: true }));
      contentInput.dispatchEvent(new Event('change', { bubbles: true }));

      // 输入完成后等待2秒
      await this.delay(2);

      contentInput.classList.remove('content-filler-highlight');
      this.showStatus('✅ 内容填写完成');

      return true;
    } catch (error) {
      console.error('填写内容失败:', error);
      this.showStatus('❌ 填写内容失败');
      return false;
    }
  }

  // 选择内容类型
  async selectContentType (contentType) {
    try {
      console.log('🎬 选择内容类型:', contentType);
      this.showStatus('🎬 选择内容类型...');

      // 等待3秒后开始选择
      await this.delay(3);

      // 根据内容类型查找对应的选择器
      let typeSelectors = [];
      if (contentType === 'video') {
        typeSelectors = [
          'input[value="video"]',
          'input[type="radio"][value="video"]',
          '.video-option',
          '[data-testid="video-option"]'
        ];
      } else if (contentType === 'image') {
        typeSelectors = [
          'input[value="image"]',
          'input[type="radio"][value="image"]',
          '.image-option',
          '[data-testid="image-option"]'
        ];
      }

      const typeInput = await this.waitForElement(typeSelectors);
      typeInput.classList.add('content-filler-highlight');

      // 延时2秒后点击
      await this.delay(2);
      typeInput.click();

      // 点击后等待3秒
      await this.delay(3);

      typeInput.classList.remove('content-filler-highlight');
      this.showStatus('✅ 内容类型选择完成');

      return true;
    } catch (error) {
      console.error('选择内容类型失败:', error);
      this.showStatus('❌ 选择内容类型失败');
      return false;
    }
  }

  // 上传视频文件
  async uploadVideo (videoPath) {
    try {
      console.log('🎯 开始上传视频:', videoPath);
      this.showStatus('🎯 开始上传视频...');

      // 等待3秒后开始上传
      await this.delay(3);

      // 等待文件上传区域出现
      const uploadSelectors = [
        '.container-drag-VAfIfu',
        '.upload-area',
        '[role="presentation"]',
        '.container-drag-info-efu4jl',
        '.container-drag'
      ];

      const uploadArea = await this.waitForElement(uploadSelectors);

      // 高亮显示
      uploadArea.classList.add('content-filler-highlight');

      // 延时2秒后继续
      await this.delay(2);

      // 查找隐藏的文件输入框
      const fileInput = uploadArea.querySelector('input[type="file"]');
      if (!fileInput) {
        throw new Error('未找到文件输入框');
      }

      console.log('📁 找到文件输入框:', fileInput);
      console.log('📁 文件输入框属性:', {
        type: fileInput.type,
        accept: fileInput.accept,
        multiple: fileInput.multiple,
        disabled: fileInput.disabled
      });

      // 延时2秒后开始处理文件
      await this.delay(2);

      // 尝试创建File对象并上传
      try {
        let videoFile = null;

        // 处理网络视频地址
        if (videoPath.startsWith('http://') || videoPath.startsWith('https://')) {
          console.log('🔗 检测到网络视频地址，开始下载...');

          try {
            // 设置下载选项
            const fetchOptions = {
              method: 'GET',
              headers: {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
              }
            };

            console.log('📥 开始下载视频文件...');
            const response = await window.electronAPI.fetch(videoPath, fetchOptions);

            if (response.ok) {
              console.log('✅ 视频下载成功，状态码:', response.status);

              // 获取视频内容
              const videoBlob = await response.blob();
              console.log('📁 视频Blob对象:', videoBlob);
              console.log('📊 Blob属性:', {
                size: videoBlob.size,
                type: videoBlob.type
              });

              // 从URL中提取文件名
              const urlParts = videoPath.split('/');
              let fileName = urlParts[urlParts.length - 1] || 'video.mp4';

              // 如果文件名没有扩展名，根据MIME类型添加
              let finalFileName = fileName;
              let finalMimeType = videoBlob.type;

              if (!fileName.includes('.')) {
                // 根据MIME类型确定扩展名
                if (videoBlob.type.includes('mp4') || videoBlob.type.includes('video/mp4')) {
                  finalFileName = fileName + '.mp4';
                  finalMimeType = 'video/mp4';
                } else if (videoBlob.type.includes('webm') || videoBlob.type.includes('video/webm')) {
                  finalFileName = fileName + '.webm';
                  finalMimeType = 'video/webm';
                } else if (videoBlob.type.includes('mov') || videoBlob.type.includes('video/quicktime')) {
                  finalFileName = fileName + '.mov';
                  finalMimeType = 'video/quicktime';
                } else if (videoBlob.type.includes('avi') || videoBlob.type.includes('video/x-msvideo')) {
                  finalFileName = fileName + '.avi';
                  finalMimeType = 'video/x-msvideo';
                } else {
                  // 默认使用mp4格式
                  finalFileName = fileName + '.mp4';
                  finalMimeType = 'video/mp4';
                }
              } else {
                // 如果文件名有扩展名，确保MIME类型匹配
                const extension = fileName.split('.').pop().toLowerCase();
                switch (extension) {
                  case 'mp4':
                    finalMimeType = 'video/mp4';
                    break;
                  case 'webm':
                    finalMimeType = 'video/webm';
                    break;
                  case 'mov':
                    finalMimeType = 'video/quicktime';
                    break;
                  case 'avi':
                    finalMimeType = 'video/x-msvideo';
                    break;
                  default:
                    finalMimeType = 'video/mp4';
                }
              }

              console.log('📁 文件名处理结果:', {
                原始文件名: fileName,
                最终文件名: finalFileName,
                原始MIME类型: videoBlob.type,
                最终MIME类型: finalMimeType
              });

              // 创建File对象
              videoFile = new File([videoBlob], finalFileName, {
                type: finalMimeType,
                lastModified: Date.now()
              });

              console.log('✅ 成功创建视频File对象:', videoFile);
              console.log('📁 File对象属性:', {
                name: videoFile.name,
                size: videoFile.size,
                type: videoFile.type,
                lastModified: videoFile.lastModified
              });

              // 确保文件类型是抖音支持的格式
              const supportedTypes = ['video/mp4', 'video/webm', 'video/quicktime', 'video/x-msvideo'];
              if (!supportedTypes.includes(videoFile.type)) {
                console.log('⚠️ 文件类型不在支持列表中，转换为mp4格式...');
                videoFile = new File([videoBlob], finalFileName.replace(/\.[^/.]+$/, '.mp4'), {
                  type: 'video/mp4',
                  lastModified: Date.now()
                });
                console.log('📁 已转换为mp4格式:', videoFile);
              }

            } else {
              throw new Error(`下载失败，HTTP状态码: ${response.status}`);
            }

          } catch (fetchError) {
            console.error('❌ 视频下载失败:', fetchError);

            // 如果下载失败，创建一个模拟文件作为备选方案
            console.log('⚠️ 创建模拟视频文件作为备选...');
            const videoContent = new ArrayBuffer(1024 * 1024); // 1MB
            videoFile = new File([videoContent], 'video.mp4', {
              type: 'video/mp4',
              lastModified: Date.now()
            });
            console.log('📁 创建了模拟视频文件:', videoFile);
          }

        } else if (videoPath.startsWith('file://') || videoPath.includes('/') || videoPath.includes('\\')) {
          // 本地文件路径处理
          console.log('📁 检测到本地文件路径，尝试创建File对象...');

          const fileName = videoPath.split('/').pop() || videoPath.split('\\').pop() || 'video.mp4';
          const videoContent = new ArrayBuffer(1024 * 1024);

          // 根据文件扩展名确定MIME类型
          let mimeType = 'video/mp4';
          if (fileName.includes('.')) {
            const extension = fileName.split('.').pop().toLowerCase();
            switch (extension) {
              case 'mp4':
                mimeType = 'video/mp4';
                break;
              case 'webm':
                mimeType = 'video/webm';
                break;
              case 'mov':
                mimeType = 'video/quicktime';
                break;
              case 'avi':
                mimeType = 'video/x-msvideo';
                break;
              default:
                mimeType = 'video/mp4';
            }
          }

          videoFile = new File([videoContent], fileName, {
            type: mimeType,
            lastModified: Date.now()
          });

          console.log('📁 创建的本地File对象:', videoFile);

        } else {
          // 默认创建模拟文件
          console.log('📁 创建默认模拟视频文件...');
          const videoContent = new ArrayBuffer(1024 * 1024);
          videoFile = new File([videoContent], 'video.mp4', {
            type: 'video/mp4',
            lastModified: Date.now()
          });
        }

        if (videoFile) {
          console.log('📁 准备设置视频文件到输入框...');

          // 延时2秒后设置文件
          await this.delay(2);

          // 方法1：使用DataTransfer API
          try {
            console.log('🔄 尝试使用DataTransfer API...');
            const dataTransfer = new DataTransfer();
            dataTransfer.items.add(videoFile);
            fileInput.files = dataTransfer.files;
            console.log('✅ 使用DataTransfer设置文件成功');

          } catch (dataTransferError) {
            console.warn('⚠️ DataTransfer方法失败，尝试其他方法:', dataTransferError);

            // 方法2：直接设置files属性
            try {
              console.log('🔄 尝试使用Object.defineProperty...');
              Object.defineProperty(fileInput, 'files', {
                value: [videoFile],
                writable: true,
                configurable: true
              });
              console.log('✅ 使用Object.defineProperty设置文件成功');

            } catch (definePropertyError) {
              console.warn('⚠️ Object.defineProperty方法失败:', definePropertyError);

              // 方法3：尝试触发文件选择对话框
              console.log('🔄 尝试触发文件选择对话框...');
              fileInput.click();

              // 等待用户选择文件
              await this.delay(2);
            }
          }

          // 检查文件是否成功设置
          console.log('📁 检查文件设置结果...');
          console.log('📁 输入框files属性:', fileInput.files);
          console.log('📁 输入框files长度:', fileInput.files ? fileInput.files.length : 'undefined');

          if (fileInput.files && fileInput.files.length > 0) {
            console.log('✅ 文件已成功设置到输入框');
            console.log('📁 设置的文件:', fileInput.files[0]);
            this.showStatus('✅ 视频文件已选择');
          } else {
            console.log('⚠️ 文件可能未成功设置');
          }
        }

        // 延时2秒后触发文件选择事件
        await this.delay(2);

        // 触发文件选择事件
        console.log('📁 触发文件选择事件...');
        fileInput.dispatchEvent(new Event('change', { bubbles: true }));
        fileInput.dispatchEvent(new Event('input', { bubbles: true }));
        fileInput.dispatchEvent(new Event('drop', { bubbles: true }));

        console.log('✅ 已触发所有文件选择事件');

        // 等待一下让文件处理完成
        await this.delay(3);

      } catch (fileError) {
        console.warn('⚠️ 文件对象创建失败，尝试模拟上传:', fileError);

        // 如果无法创建File对象，至少触发change事件
        fileInput.dispatchEvent(new Event('change', { bubbles: true }));
        console.log('✅ 已触发文件选择事件（模拟模式）');
      }

      // 移除高亮
      setTimeout(() => {
        uploadArea.classList.remove('content-filler-highlight');
      }, 2000);

      this.showStatus('视频上传区域已准备就绪');
      console.log('视频上传区域准备完成');

      // 等待上传完成 - 这里需要检测上传状态
      await this.waitForUploadComplete();

      return true;
    } catch (error) {
      console.error('视频上传失败:', error);
      this.showStatus('视频上传失败');
      return false;
    }
  }

  // 上传图片文件
  async uploadImage (imagePath) {
    try {
      console.log('🖼️ 开始上传图片:', imagePath);
      this.showStatus('🖼️ 开始上传图片...');

      // 等待3秒后开始上传
      await this.delay(3);

      // 等待图片上传区域出现 - 使用抖音图文上传的特定选择器
      // 根据你提供的HTML，图文上传区域有特定的class和结构
      const uploadSelectors = [
        // 抖音图文上传的特定选择器 - 基于你提供的HTML
        '.container-drag-VAfIfu',
        '.container-drag-info-efu4jl',
        // 包含"上传图文"按钮的容器
        'div:has(button:contains("上传图文"))',
        'div:has(.container-drag-upload-tL99XD)',
        // 包含"点击上传 或直接将图片文件拖入此区域"文字的容器
        'div:has(.container-drag-title-UafWje)',
        // 包含"最多支持上传35张图片，图片格式不支持gif格式"文字的容器
        'div:has(.container-drag-sub-title-Y0B74w)',
        // 通用上传区域
        '.upload-area',
        '.image-upload-area',
        '[role="presentation"]',
        // 文件输入框
        'input[type="file"]',
        // 包含上传文字的容器
        'div:contains("点击上传或直接将图片文件拖入此区域")',
        'div:contains("上传图文")',
        'div[class*="upload"]',
        'div[class*="drag"]'
      ];

      console.log('🔍 开始查找图文上传区域...');
      let uploadArea = null;

      // 优先查找包含"上传图文"按钮的容器
      for (const selector of uploadSelectors) {
        try {
          if (selector.includes('contains')) {
            // 使用文本内容查找
            const elements = document.querySelectorAll('div, button, span');
            for (const element of elements) {
              if (element.textContent && element.textContent.includes('上传图文')) {
                // 找到包含"上传图文"的元素，向上查找上传区域
                let parent = element.closest('.container-drag-VAfIfu') ||
                  element.closest('[role="presentation"]') ||
                  element.closest('div[class*="drag"]');
                if (parent) {
                  uploadArea = parent;
                  console.log('✅ 通过"上传图文"按钮找到上传区域:', parent);
                  break;
                }
              }
            }
            if (uploadArea) break;
          } else {
            const element = document.querySelector(selector);
            if (element) {
              // 验证这个元素是否真的是图文上传区域
              if (element.textContent &&
                (element.textContent.includes('上传图文') ||
                  element.textContent.includes('点击上传') ||
                  element.textContent.includes('最多支持上传35张图片'))) {
                uploadArea = element;
                console.log('✅ 找到图文上传区域:', selector, element);
                break;
              }
            }
          }
        } catch (e) {
          console.log('⚠️ 选择器查找失败:', selector, e.message);
        }
      }

      if (!uploadArea) {
        // 如果还是没找到，尝试在整个页面查找包含相关文字的元素
        console.log('🔍 尝试在整个页面查找图文上传相关元素...');
        const allElements = document.querySelectorAll('*');
        for (const element of allElements) {
          if (element.textContent &&
            (element.textContent.includes('上传图文') ||
              element.textContent.includes('点击上传 或直接将图片文件拖入此区域') ||
              element.textContent.includes('最多支持上传35张图片，图片格式不支持gif格式'))) {
            // 向上查找上传区域容器
            let parent = element.closest('.container-drag-VAfIfu') ||
              element.closest('[role="presentation"]') ||
              element.closest('div[class*="drag"]');
            if (parent) {
              uploadArea = parent;
              console.log('✅ 通过文本内容找到图文上传区域:', parent);
              break;
            }
          }
        }
      }

      if (!uploadArea) {
        throw new Error('未找到图文上传区域');
      }

      console.log('🎯 找到图文上传区域:', uploadArea);
      console.log('📝 上传区域文本内容:', uploadArea.textContent);

      // 高亮显示
      uploadArea.classList.add('content-filler-highlight');

      // 延时2秒后继续
      await this.delay(2);

      // 查找隐藏的文件输入框 - 优先在找到的上传区域内查找
      let fileInput = uploadArea.querySelector('input[type="file"]');
      if (!fileInput) {
        console.log('🔍 在上传区域内未找到文件输入框，尝试在整个页面查找...');
        // 在整个页面查找文件输入框
        const allFileInputs = document.querySelectorAll('input[type="file"]');
        console.log('📁 页面中找到的文件输入框数量:', allFileInputs.length);

        // 遍历所有文件输入框，找到图文相关的
        for (const input of allFileInputs) {
          console.log('🔍 检查文件输入框:', input);
          console.log('📝 输入框属性:', {
            accept: input.accept,
            multiple: input.multiple,
            type: input.type,
            style: input.style.cssText
          });

          // 检查accept属性，图文上传应该包含图片格式，视频上传包含视频格式
          if (input.accept) {
            if (input.accept.includes('image/')) {
              console.log('✅ 找到图片文件输入框:', input);
              fileInput = input;
              break;
            } else if (input.accept.includes('video/')) {
              console.log('⚠️ 这是视频文件输入框，跳过:', input.accept);
              continue;
            }
          }
        }

        if (!fileInput) {
          // 如果还是没找到，尝试通过其他方式查找
          console.log('🔍 尝试通过其他方式查找图片文件输入框...');

          // 方法1：查找包含图片格式的accept属性
          for (const input of allFileInputs) {
            if (input.accept && input.accept.includes('image/')) {
              console.log('✅ 通过accept属性找到图片文件输入框:', input);
              fileInput = input;
              break;
            }
          }

          // 方法2：如果还是没找到，查找没有accept属性或accept为空的输入框
          if (!fileInput) {
            for (const input of allFileInputs) {
              if (!input.accept || input.accept === '' || input.accept === '*') {
                console.log('⚠️ 找到通用文件输入框，可能是图片上传:', input);
                fileInput = input;
                break;
              }
            }
          }

          // 方法3：最后备选，使用第一个文件输入框
          if (!fileInput) {
            if (allFileInputs.length > 0) {
              fileInput = allFileInputs[0];
              console.log('⚠️ 使用第一个找到的文件输入框作为备选:', fileInput);
            } else {
              throw new Error('未找到图片文件输入框');
            }
          }
        }
      }

      // 验证找到的文件输入框是否真的是图片上传的
      if (fileInput && fileInput.accept) {
        if (fileInput.accept.includes('video/')) {
          console.log('❌ 错误：找到的是视频文件输入框，不是图片的！');
          console.log('📹 视频accept属性:', fileInput.accept);

          // 尝试重新查找图片文件输入框
          console.log('🔄 重新查找图片文件输入框...');
          const allFileInputs = document.querySelectorAll('input[type="file"]');
          for (const input of allFileInputs) {
            if (input.accept && input.accept.includes('image/')) {
              console.log('✅ 重新找到图片文件输入框:', input);
              fileInput = input;
              break;
            }
          }

          if (fileInput.accept && fileInput.accept.includes('video/')) {
            throw new Error('无法找到图片文件输入框，只找到了视频的');
          }
        } else if (fileInput.accept.includes('image/')) {
          console.log('✅ 确认找到的是图片文件输入框');
        }
      }

      console.log('🖼️ 找到图片文件输入框:', fileInput);
      console.log('🖼️ 文件输入框属性:', {
        type: fileInput.type,
        accept: fileInput.accept,
        multiple: fileInput.multiple,
        disabled: fileInput.disabled,
        style: fileInput.style.cssText
      });

      // 延时2秒后开始处理文件
      await this.delay(2);

      // 尝试创建File对象并上传
      try {
        let imageFile = null;

        // 处理网络图片地址
        if (imagePath.startsWith('http://') || imagePath.startsWith('https://')) {
          console.log('🔗 检测到网络图片地址，开始下载...');

          try {
            // 设置下载选项
            const fetchOptions = {
              method: 'GET',
              headers: {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
              }
            };

            console.log('📥 开始下载图片文件...');
            const response = await window.electronAPI.fetch(imagePath, fetchOptions);

            if (response.ok) {
              console.log('✅ 图片下载成功，状态码:', response.status);

              // 获取图片内容
              const imageBlob = await response.blob();
              console.log('🖼️ 图片Blob对象:', imageBlob);
              console.log('📊 Blob属性:', {
                size: imageBlob.size,
                type: imageBlob.type
              });

              // 从URL中提取文件名
              const urlParts = imagePath.split('/');
              let fileName = urlParts[urlParts.length - 1] || 'image.jpg';

              // 如果文件名没有扩展名，根据MIME类型添加
              let finalFileName = fileName;
              let finalMimeType = imageBlob.type;

              if (!fileName.includes('.')) {
                // 根据MIME类型确定扩展名
                if (imageBlob.type.includes('jpeg') || imageBlob.type.includes('jpg')) {
                  finalFileName = fileName + '.jpg';
                  finalMimeType = 'image/jpeg';
                } else if (imageBlob.type.includes('png')) {
                  finalFileName = fileName + '.png';
                  finalMimeType = 'image/png';
                } else if (imageBlob.type.includes('webp')) {
                  finalFileName = fileName + '.webp';
                  finalMimeType = 'image/webp';
                } else {
                  // 默认使用jpg格式
                  finalFileName = fileName + '.jpg';
                  finalMimeType = 'image/jpeg';
                }
              } else {
                // 如果文件名有扩展名，确保MIME类型匹配
                const extension = fileName.split('.').pop().toLowerCase();
                switch (extension) {
                  case 'jpg':
                  case 'jpeg':
                    finalMimeType = 'image/jpeg';
                    break;
                  case 'png':
                    finalMimeType = 'image/png';
                    break;
                  case 'webp':
                    finalMimeType = 'image/webp';
                    break;
                  default:
                    // 不支持GIF格式，转换为JPEG
                    finalMimeType = 'image/jpeg';
                    finalFileName = fileName.replace(/\.[^/.]+$/, '.jpg');
                }
              }

              console.log('🖼️ 文件名处理结果:', {
                原始文件名: fileName,
                最终文件名: finalFileName,
                原始MIME类型: imageBlob.type,
                最终MIME类型: finalMimeType
              });

              // 创建File对象
              imageFile = new File([imageBlob], finalFileName, {
                type: finalMimeType,
                lastModified: Date.now()
              });

              console.log('✅ 成功创建图片File对象:', imageFile);
              console.log('🖼️ File对象属性:', {
                name: imageFile.name,
                size: imageFile.size,
                type: imageFile.type,
                lastModified: imageFile.lastModified
              });

              // 验证图片格式是否符合抖音图文要求
              if (!this.validateImageForDouyin(imageFile)) {
                console.log('⚠️ 图片格式不符合抖音图文要求，尝试转换...');
                imageFile = this.convertImageForDouyin(imageBlob, finalFileName);

                // 再次验证转换后的图片
                if (!this.validateImageForDouyin(imageFile)) {
                  console.log('❌ 图片转换后仍不符合要求，使用默认格式...');
                  // 创建标准的JPEG图片
                  const standardContent = new ArrayBuffer(1024 * 100); // 100KB
                  imageFile = new File([standardContent], 'image.jpg', {
                    type: 'image/jpeg',
                    lastModified: Date.now()
                  });
                }
              }

            } else {
              throw new Error(`下载失败，HTTP状态码: ${response.status}`);
            }

          } catch (fetchError) {
            console.error('❌ 图片下载失败:', fetchError);

            // 如果下载失败，创建一个模拟文件作为备选方案
            console.log('⚠️ 创建模拟图片文件作为备选...');
            const imageContent = new ArrayBuffer(1024 * 100); // 100KB
            imageFile = new File([imageContent], 'image.jpg', {
              type: 'image/jpeg',
              lastModified: Date.now()
            });
            console.log('🖼️ 创建了模拟图片文件:', imageFile);
          }

        } else if (imagePath.startsWith('file://') || imagePath.includes('/') || imagePath.includes('\\')) {
          // 本地文件路径处理
          console.log('🖼️ 检测到本地文件路径，尝试创建File对象...');

          const fileName = imagePath.split('/').pop() || imagePath.split('\\').pop() || 'image.jpg';
          const imageContent = new ArrayBuffer(1024 * 100);

          // 根据文件扩展名确定MIME类型
          let mimeType = 'image/jpeg';
          if (fileName.includes('.')) {
            const extension = fileName.split('.').pop().toLowerCase();
            switch (extension) {
              case 'jpg':
              case 'jpeg':
                mimeType = 'image/jpeg';
                break;
              case 'png':
                mimeType = 'image/png';
                break;
              case 'webp':
                mimeType = 'image/webp';
                break;
              default:
                // 不支持GIF格式，转换为JPEG
                mimeType = 'image/jpeg';
            }
          }

          imageFile = new File([imageContent], fileName, {
            type: mimeType,
            lastModified: Date.now()
          });

          console.log('🖼️ 创建的本地图片File对象:', imageFile);

        } else {
          // 默认创建模拟文件
          console.log('🖼️ 创建默认模拟图片文件...');
          const imageContent = new ArrayBuffer(1024 * 100);
          imageFile = new File([imageContent], 'image.jpg', {
            type: 'image/jpeg',
            lastModified: Date.now()
          });
        }

        if (imageFile) {
          console.log('🖼️ 准备设置图片文件到输入框...');

          // 延时2秒后设置文件
          await this.delay(2);

          // 方法1：使用DataTransfer API
          try {
            console.log('🔄 尝试使用DataTransfer API...');
            const dataTransfer = new DataTransfer();
            dataTransfer.items.add(imageFile);
            fileInput.files = dataTransfer.files;
            console.log('✅ 使用DataTransfer设置图片文件成功');

          } catch (dataTransferError) {
            console.warn('⚠️ DataTransfer方法失败，尝试其他方法:', dataTransferError);

            // 方法2：直接设置files属性
            try {
              console.log('🔄 尝试使用Object.defineProperty...');
              Object.defineProperty(fileInput, 'files', {
                value: [imageFile],
                writable: true,
                configurable: true
              });
              console.log('✅ 使用Object.defineProperty设置图片文件成功');

            } catch (definePropertyError) {
              console.warn('⚠️ Object.defineProperty方法失败:', definePropertyError);

              // 方法3：尝试触发文件选择对话框
              console.log('🔄 尝试触发文件选择对话框...');
              fileInput.click();

              // 等待用户选择文件
              await this.delay(2);
            }
          }

          // 检查文件是否成功设置
          console.log('🖼️ 检查图片文件设置结果...');
          console.log('🖼️ 输入框files属性:', fileInput.files);
          console.log('🖼️ 输入框files长度:', fileInput.files ? fileInput.files.length : 'undefined');

          if (fileInput.files && fileInput.files.length > 0) {
            console.log('✅ 图片文件已成功设置到输入框');
            console.log('🖼️ 设置的文件:', fileInput.files[0]);
            this.showStatus('✅ 图片文件已选择');
          } else {
            console.log('⚠️ 图片文件可能未成功设置');
          }
        }

        // 延时2秒后触发文件选择事件
        await this.delay(2);

        // 触发文件选择事件
        console.log('🖼️ 触发图片文件选择事件...');
        fileInput.dispatchEvent(new Event('change', { bubbles: true }));
        fileInput.dispatchEvent(new Event('input', { bubbles: true }));
        fileInput.dispatchEvent(new Event('drop', { bubbles: true }));

        console.log('✅ 已触发所有图片文件选择事件');

        // 等待图片上传完成
        console.log('⏳ 等待图片上传完成...');
        await this.waitForImageUploadComplete();

        // 移除高亮
        setTimeout(() => {
          uploadArea.classList.remove('content-filler-highlight');
        }, 2000);

        this.showStatus('✅ 图片上传完成');
        console.log('✅ 图片上传完成');

        return true;
      } catch (fileError) {
        console.warn('⚠️ 图片文件对象创建失败，尝试模拟上传:', fileError);

        // 如果无法创建File对象，至少触发change事件
        fileInput.dispatchEvent(new Event('change', { bubbles: true }));
        console.log('✅ 已触发图片文件选择事件（模拟模式）');
      }

      // 移除高亮
      setTimeout(() => {
        uploadArea.classList.remove('content-filler-highlight');
      }, 2000);

      this.showStatus('图片上传区域已准备就绪');
      console.log('图片上传区域准备完成');

      return true;
    } catch (error) {
      console.error('图片上传失败:', error);
      this.showStatus('图片上传失败');
      return false;
    }
  }

  // 等待文件上传完成
  async waitForUploadComplete () {
    try {
      console.log('⏳ 等待文件上传完成...');

      // 等待上传进度条或状态指示器出现 - 使用更多抖音特有的选择器
      const progressSelectors = [
        // 抖音特有的上传状态选择器
        '.upload-progress',
        '.progress-bar',
        '.upload-status',
        '.uploading',
        '[class*="progress"]',
        '[class*="uploading"]',
        // 抖音可能使用的其他选择器
        '.container-drag-VAfIfu .uploading',
        '.container-drag-info-efu4jl .uploading',
        '[class*="upload"]',
        '[class*="progress"]',
        // 通用选择器
        '.loading',
        '.spinner',
        '[class*="loading"]',
        '[class*="spinner"]'
      ];

      // 尝试等待上传开始，但不要强制要求
      let uploadStarted = false;
      try {
        await this.waitForElement(progressSelectors, 5000); // 缩短等待时间
        uploadStarted = true;
        this.showStatus('文件上传中...');
        console.log('✅ 检测到上传进度指示器');
      } catch (error) {
        console.log('⚠️ 未检测到上传进度指示器，继续等待...');
        // 即使没有进度指示器，也继续等待
        uploadStarted = false;
      }

      // 等待上传完成 - 使用多种检测方法
      let uploadComplete = false;
      let attempts = 0;
      const maxAttempts = 30; // 减少到30秒

      while (!uploadComplete && attempts < maxAttempts) {
        attempts++;

        // 方法1：检查是否有上传完成的指示器
        const completeSelectors = [
          '.upload-complete',
          '.upload-success',
          '.upload-done',
          '[class*="complete"]',
          '[class*="success"]',
          '[class*="done"]',
          // 抖音特有的完成状态
          '.container-drag-VAfIfu .complete',
          '.container-drag-info-efu4jl .complete'
        ];

        for (const selector of completeSelectors) {
          const element = document.querySelector(selector);
          if (element) {
            uploadComplete = true;
            console.log('✅ 检测到上传完成指示器:', selector);
            break;
          }
        }

        // 方法2：检查进度条是否消失（表示上传完成）
        if (uploadStarted) {
          const progressElement = document.querySelector(progressSelectors.join(','));
          if (!progressElement) {
            // 进度条消失，可能表示上传完成
            uploadComplete = true;
            console.log('✅ 进度条消失，可能上传完成');
          }
        }

        // 方法3：检查页面URL变化（最可靠的方法）
        if (!uploadComplete) {
          const currentUrl = window.location.href;
          if (currentUrl.includes('/creator-micro/content/post/video') ||
            currentUrl.includes('enter_from=publish_page')) {
            uploadComplete = true;
            console.log('✅ 检测到页面跳转到视频发布页面:', currentUrl);
            break;
          }
        }

        // 方法4：检查页面状态变化
        if (!uploadComplete) {
          // 检查是否有新的内容区域出现，表示上传完成
          const newContentSelectors = [
            'input[placeholder*="标题"]',
            'textarea[placeholder*="内容"]',
            'textarea[placeholder*="描述"]',
            '.semi-input',
            '.semi-textarea'
          ];

          for (const selector of newContentSelectors) {
            const element = document.querySelector(selector);
            if (element && element.offsetParent !== null) { // 确保元素可见
              uploadComplete = true;
              console.log('✅ 检测到新的内容输入区域，可能上传完成');
              break;
            }
          }
        }

        // 检查是否有错误提示
        const errorSelectors = [
          '.upload-error',
          '.error-message',
          '[class*="error"]',
          '.alert-error',
          '.alert-danger'
        ];

        for (const selector of errorSelectors) {
          const element = document.querySelector(selector);
          if (element) {
            throw new Error(`上传失败: ${element.textContent}`);
          }
        }

        if (!uploadComplete) {
          // 显示等待状态
          this.showDelay(`等待上传完成... ${attempts}s`, 1000);
          await new Promise(resolve => setTimeout(resolve, 1000));
        }
      }

      if (uploadComplete) {
        this.showStatus('✅ 文件上传完成！');
        console.log('✅ 文件上传完成');

        // 等待页面完全加载
        await new Promise(resolve => setTimeout(resolve, 3000));

        return true;
      } else {
        // 如果超时但没有错误，假设上传完成
        console.log('⚠️ 上传检测超时，假设上传完成');
        this.showStatus('⚠️ 上传检测超时，继续后续操作');
        return true;
      }

    } catch (error) {
      console.error('等待上传完成失败:', error);
      this.showStatus('上传超时或失败');
      throw error;
    }
  }

  // 等待页面跳转完成
  async waitForPageNavigation () {
    try {
      console.log('🔄 等待页面跳转完成...');

      // 等待页面URL变化
      let attempts = 0;
      const maxAttempts = 20;

      while (attempts < maxAttempts) {
        const currentUrl = window.location.href;

        // 检查是否已经跳转到视频发布页面
        if (currentUrl.includes('/creator-micro/content/post/video') ||
          currentUrl.includes('enter_from=publish_page')) {
          console.log('✅ 页面已跳转到视频发布页面:', currentUrl);

          // 等待页面完全加载
          await new Promise(resolve => setTimeout(resolve, 2000));

          // 等待页面元素加载完成
          await this.waitForPageElements();

          return true;
        }

        attempts++;
        this.showDelay(`等待页面跳转... ${attempts}s`, 1000);
        await new Promise(resolve => setTimeout(resolve, 1000));
      }

      console.log('⚠️ 页面跳转超时，继续执行');
      return false;

    } catch (error) {
      console.error('等待页面跳转失败:', error);
      return false;
    }
  }

  // 等待页面元素加载完成
  async waitForPageElements () {
    try {
      console.log('⏳ 等待页面元素加载完成...');

      // 等待关键元素出现
      const keyElements = [
        'input[placeholder*="标题"]',
        'textarea[placeholder*="内容"]',
        'textarea[placeholder*="描述"]',
        '.semi-input',
        '.semi-textarea'
      ];

      for (const selector of keyElements) {
        try {
          await this.waitForElement([selector], 10000);
          console.log(`✅ 找到元素: ${selector}`);
        } catch (error) {
          console.log(`⚠️ 未找到元素: ${selector}`);
        }
      }

      console.log('✅ 页面元素加载完成');

    } catch (error) {
      console.error('等待页面元素加载失败:', error);
    }
  }

  // 填写标签
  async fillTags (tags) {
    try {
      if (!tags || tags.trim() === '') {
        console.log('🏷️ 没有标签需要填写');
        return true;
      }

      console.log('🏷️ 填写标签:', tags);
      this.showStatus('🏷️ 填写标签...');

      // 等待3秒后开始填写
      await this.delay(3);

      // 标签和内容是同一个区域，使用和内容填写相同的选择器
      const tagsInput = await this.waitForElement([
        'div[data-placeholder*="作品简介"]',
        'div[data-placeholder*="简介"]',
        'div[data-placeholder*="描述"]',
        'div[data-placeholder*="内容"]',
        'div[contenteditable="true"][data-placeholder]',
        'div[data-slate-editor="true"]',
        'div.editor-kit-container',
        'div[contenteditable="true"]'
      ]);

      console.log('🏷️ 找到标签/内容输入区域:', tagsInput);
      console.log('📝 输入区域属性:', {
        contentEditable: tagsInput.contentEditable,
        placeholder: tagsInput.getAttribute('data-placeholder') || tagsInput.placeholder,
        tagName: tagsInput.tagName,
        className: tagsInput.className
      });

      tagsInput.classList.add('content-filler-highlight');

      // 延时2秒后开始输入
      await this.delay(2);

      // 获取当前内容区域的现有内容
      let currentContent = '';
      if (tagsInput.contentEditable === 'true') {
        currentContent = tagsInput.textContent || tagsInput.innerText || '';
      } else {
        currentContent = tagsInput.value || '';
      }

      console.log('📝 当前内容区域内容:', currentContent);

      // 如果内容区域已经有内容，在末尾添加标签
      let finalContent = currentContent;
      if (currentContent.trim() !== '') {
        // 在现有内容后添加换行和标签
        finalContent = '' + tags;
        console.log('🏷️ 在现有内容后添加标签，最终内容:', finalContent);
      } else {
        // 如果内容区域为空，直接设置标签
        finalContent = tags;
        console.log('🏷️ 内容区域为空，直接设置标签:', finalContent);
      }

      // 延时1秒后输入内容
      await this.delay(1);

      // 设置最终内容（内容+标签）
      if (tagsInput.contentEditable === 'true') {
        tagsInput.textContent = finalContent;
      } else {
        tagsInput.value = finalContent;
      }

      // 触发输入事件
      tagsInput.dispatchEvent(new Event('input', { bubbles: true }));
      tagsInput.dispatchEvent(new Event('change', { bubbles: true }));

      // 输入完成后等待2秒
      await this.delay(2);

      tagsInput.classList.remove('content-filler-highlight');
      this.showStatus('✅ 标签填写完成（已添加到内容区域）');

      console.log('✅ 标签已成功添加到内容区域');
      return true;
    } catch (error) {
      console.error('填写标签失败:', error);
      this.showStatus('❌ 填写标签失败');
      return false;
    }
  }

  // 点击发布按钮
  async clickPublishButton () {
    try {
      console.log('🚀 点击发布按钮');
      this.showStatus('🚀 点击发布按钮...');

      // 等待3秒后开始点击
      await this.delay(3);

      // 使用多种策略查找发布按钮
      let publishButton = null;

      // 策略1：通过具体的class组合查找
      try {
        publishButton = document.querySelector('button.button-dhlUZE.primary-cECiOJ.fixed-J9O8Yw');
        if (publishButton) {
          console.log('✅ 通过具体class组合找到发布按钮');
        }
      } catch (e) {
        console.log('⚠️ 具体class查找失败，尝试其他方法');
      }

      // 策略2：通过部分class名查找
      if (!publishButton) {
        try {
          publishButton = document.querySelector('button[class*="button-dhlUZE"]') ||
            document.querySelector('button[class*="primary-cECiOJ"]') ||
            document.querySelector('button[class*="fixed-J9O8Yw"]');
          if (publishButton) {
            console.log('✅ 通过部分class名找到发布按钮');
          }
        } catch (e) {
          console.log('⚠️ 部分class查找失败，尝试其他方法');
        }
      }

      // 策略3：通过样式属性查找
      if (!publishButton) {
        try {
          publishButton = document.querySelector('button[style*="width: 120px"]') ||
            document.querySelector('button[style*="height: 32px"]');
          if (publishButton) {
            console.log('✅ 通过样式属性找到发布按钮');
          }
        } catch (e) {
          console.log('⚠️ 样式属性查找失败，尝试其他方法');
        }
      }

      // 策略4：通过容器ID查找
      if (!publishButton) {
        try {
          const container = document.querySelector('span#popover-tip-container');
          if (container) {
            publishButton = container.querySelector('button');
            if (publishButton) {
              console.log('✅ 通过容器ID找到发布按钮');
            }
          }
        } catch (e) {
          console.log('⚠️ 容器ID查找失败，尝试其他方法');
        }
      }

      // 策略5：通过文本内容查找
      if (!publishButton) {
        try {
          const allButtons = document.querySelectorAll('button');
          for (const button of allButtons) {
            const buttonText = button.textContent || button.innerText || '';
            if (buttonText.includes('发布') || buttonText.includes('发布视频') || buttonText.includes('发布图文')) {
              publishButton = button;
              console.log('✅ 通过文本内容找到发布按钮:', buttonText);
              break;
            }
          }
        } catch (e) {
          console.log('⚠️ 文本内容查找失败，尝试其他方法');
        }
      }

      // 策略6：通过通用选择器查找
      if (!publishButton) {
        try {
          publishButton = document.querySelector('button[type="submit"]') ||
            document.querySelector('.publish-button') ||
            document.querySelector('[data-testid="publish-button"]') ||
            document.querySelector('button.btn-primary') ||
            document.querySelector('.submit-btn');
          if (publishButton) {
            console.log('✅ 通过通用选择器找到发布按钮');
          }
        } catch (e) {
          console.log('⚠️ 通用选择器查找失败');
        }
      }

      if (!publishButton) {
        throw new Error('未找到发布按钮，尝试了多种查找策略');
      }

      console.log('✅ 找到发布按钮，准备点击');
      publishButton.classList.add('content-filler-highlight');

      // 延时2秒后点击
      await this.delay(2);
      publishButton.click();

      // 点击后等待5秒
      await this.delay(5);

      publishButton.classList.remove('content-filler-highlight');
      this.showStatus('✅ 发布按钮点击完成');

      return true;
    } catch (error) {
      console.error('点击发布按钮失败:', error);
      this.showStatus('❌ 点击发布按钮失败');
      return false;
    }
  }

  // 切换到图文发布模式
  async switchToImageMode () {
    try {
      console.log('🖼️ 切换到图文发布模式');
      this.showStatus('🖼️ 切换到图文发布模式...');

      // 等待3秒后开始切换
      await this.delay(3);

      // 使用多种策略查找图文模式标签，确保能找到
      let imageModeButton = null;

      // 策略1：通过精确文本匹配查找
      console.log('🔍 策略1: 精确文本匹配查找...');
      const allElements = document.querySelectorAll('*');
      console.log('🔍 页面中所有元素数量:', allElements.length);

      for (const element of allElements) {
        const elementText = element.textContent || element.innerText || '';
        if (elementText.trim() === '发布图文' || elementText.trim() === '图文') {
          const style = window.getComputedStyle(element);
          if (style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0') {
            imageModeButton = element;
            console.log('✅ 策略1成功: 精确匹配找到图文标签:', elementText);
            console.log('🔍 元素标签:', element.tagName);
            console.log('🔍 元素类名:', element.className);
            break;
          }
        }
      }

      // 策略2：通过包含文本查找
      if (!imageModeButton) {
        console.log('🔍 策略2: 包含文本查找...');
        for (const element of allElements) {
          const elementText = element.textContent || element.innerText || '';
          if (elementText.includes('发布图文') || elementText.includes('图文')) {
            const style = window.getComputedStyle(element);
            if (style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0') {
              // 检查元素是否可点击
              if (element.tagName === 'BUTTON' || element.tagName === 'A' ||
                element.onclick || element.getAttribute('onclick') ||
                element.getAttribute('role') === 'button' ||
                element.style.cursor === 'pointer') {
                imageModeButton = element;
                console.log('✅ 策略2成功: 包含文本找到可点击的图文标签:', elementText);
                break;
              }
            }
          }
        }
      }

      // 策略3：通过标签容器结构查找
      if (!imageModeButton) {
        console.log('🔍 策略3: 标签容器结构查找...');

        // 查找包含多个标签的容器
        for (const element of allElements) {
          const elementText = element.textContent || element.innerText || '';
          if (elementText.includes('发布视频') && elementText.includes('发布图文')) {
            console.log('🔍 找到包含多个标签的容器:', element.tagName, element.className);

            // 在容器中查找所有子元素
            const children = element.querySelectorAll('*');
            for (const child of children) {
              const childText = child.textContent || child.innerText || '';
              if (childText.includes('发布图文') || childText.includes('图文')) {
                const style = window.getComputedStyle(child);
                if (style.display !== 'none' && style.visibility !== 'hidden') {
                  imageModeButton = child;
                  console.log('✅ 策略3成功: 容器结构找到图文标签:', childText);
                  break;
                }
              }
            }
            if (imageModeButton) break;
          }
        }
      }

      // 策略4：通过位置关系查找
      if (!imageModeButton) {
        console.log('🔍 策略4: 位置关系查找...');

        // 先找到视频标签
        let videoElement = null;
        for (const element of allElements) {
          const elementText = element.textContent || element.innerText || '';
          if (elementText.includes('发布视频')) {
            videoElement = element;
            break;
          }
        }

        if (videoElement) {
          console.log('🔍 找到视频标签，查找相邻元素...');

          // 查找同级元素
          const parent = videoElement.parentElement;
          if (parent) {
            const siblings = parent.children;
            console.log('🔍 同级元素数量:', siblings.length);

            for (let i = 0; i < siblings.length; i++) {
              const sibling = siblings[i];
              const siblingText = sibling.textContent || sibling.innerText || '';
              console.log(`🔍 同级元素 ${i}:`, siblingText);

              if (siblingText.includes('发布图文') || siblingText.includes('图文')) {
                imageModeButton = sibling;
                console.log('✅ 策略4成功: 位置关系找到图文标签:', siblingText);
                break;
              }
            }
          }
        }
      }

      // 策略5：通过DOM遍历查找
      if (!imageModeButton) {
        console.log('🔍 策略5: DOM遍历查找...');

        // 使用TreeWalker遍历所有文本节点
        const walker = document.createTreeWalker(
          document.body,
          NodeFilter.SHOW_TEXT,
          null,
          false
        );

        let textNode;
        while (textNode = walker.nextNode()) {
          const text = textNode.textContent.trim();
          if (text === '发布图文' || text === '图文') {
            const parent = textNode.parentElement;
            if (parent) {
              const style = window.getComputedStyle(parent);
              if (style.display !== 'none' && style.visibility !== 'hidden') {
                imageModeButton = parent;
                console.log('✅ 策略5成功: DOM遍历找到图文标签:', text);
                break;
              }
            }
          }
        }
      }

      // 策略6：通过事件监听器查找
      if (!imageModeButton) {
        console.log('🔍 策略6: 事件监听器查找...');

        // 查找所有可能的事件目标
        for (const element of allElements) {
          const elementText = element.textContent || element.innerText || '';
          if (elementText.includes('发布图文') || elementText.includes('图文')) {
            // 检查是否有事件监听器
            const hasEvents = element.onclick ||
              element.getAttribute('onclick') ||
              element.getAttribute('role') === 'button' ||
              element.style.cursor === 'pointer' ||
              element.classList.contains('clickable') ||
              element.classList.contains('button') ||
              element.classList.contains('tab');

            if (hasEvents) {
              imageModeButton = element;
              console.log('✅ 策略6成功: 事件监听器找到图文标签:', elementText);
              break;
            }
          }
        }
      }

      if (!imageModeButton) {
        console.log('❌ 所有策略都失败了，无法找到图文标签');
        console.log('🔍 当前页面URL:', window.location.href);
        console.log('🔍 页面标题:', document.title);
        console.log('🔍 页面内容片段:', document.body.textContent.substring(0, 500));

        throw new Error('无法找到图文发布标签，请检查页面是否正确加载');
      }

      console.log('✅ 找到图文模式标签，准备点击');
      console.log('🔍 标签文本:', imageModeButton.textContent);
      console.log('🔍 标签类型:', imageModeButton.tagName);
      console.log('🔍 标签类名:', imageModeButton.className);
      console.log('🔍 标签位置:', imageModeButton.getBoundingClientRect());

      // 高亮显示找到的元素
      imageModeButton.classList.add('content-filler-highlight');

      // 延时2秒后点击
      await this.delay(2);

      // 尝试多种点击方式
      try {
        // 方式1：直接点击
        imageModeButton.click();
        console.log('✅ 直接点击成功');
      } catch (clickError) {
        console.warn('⚠️ 直接点击失败，尝试其他方式:', clickError);

        try {
          // 方式2：触发click事件
          const clickEvent = new MouseEvent('click', {
            bubbles: true,
            cancelable: true,
            view: window
          });
          imageModeButton.dispatchEvent(clickEvent);
          console.log('✅ 事件触发点击成功');
        } catch (eventError) {
          console.warn('⚠️ 事件触发点击失败，尝试其他方式:', eventError);

          try {
            // 方式3：模拟鼠标事件
            const mouseDownEvent = new MouseEvent('mousedown', { bubbles: true });
            const mouseUpEvent = new MouseEvent('mouseup', { bubbles: true });
            imageModeButton.dispatchEvent(mouseDownEvent);
            imageModeButton.dispatchEvent(mouseUpEvent);
            console.log('✅ 鼠标事件模拟点击成功');
          } catch (mouseError) {
            console.error('❌ 所有点击方式都失败了:', mouseError);
            throw new Error('无法点击图文标签');
          }
        }
      }

      // 点击后等待3秒让页面切换
      await this.delay(3);

      // 移除高亮
      imageModeButton.classList.remove('content-filler-highlight');

      // 验证是否切换成功
      const newPageText = document.body.textContent || document.body.innerText || '';
      if (newPageText.includes('图文') || newPageText.includes('图片')) {
        console.log('✅ 页面切换验证成功');
        this.showStatus('✅ 已切换到图文发布模式');
        return true;
      } else {
        console.log('⚠️ 页面切换验证失败，可能仍在视频模式');
        this.showStatus('⚠️ 页面切换可能失败，请检查');
        return false;
      }

    } catch (error) {
      console.error('切换到图文发布模式失败:', error);
      this.showStatus('❌ 切换到图文发布模式失败');
      return false;
    }
  }

  // 切换到视频发布模式
  async switchToVideoMode () {
    try {
      console.log('🎬 切换到视频发布模式');
      this.showStatus('🎬 切换到视频发布模式...');

      // 等待3秒后开始切换
      await this.delay(3);

      // 使用多种策略查找视频模式标签，避免依赖动态class名
      let videoModeButton = null;

      // 策略1：通过文本内容查找所有可能的标签元素
      const allPossibleElements = document.querySelectorAll('div, button, span, a');
      console.log('🔍 开始查找视频模式标签...');

      for (const element of allPossibleElements) {
        const elementText = element.textContent || element.innerText || '';
        if (elementText.includes('发布视频') || elementText.includes('视频')) {
          // 检查元素是否可见和可点击
          const style = window.getComputedStyle(element);
          if (style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0') {
            videoModeButton = element;
            console.log('✅ 通过文本内容找到视频模式标签:', elementText);
            console.log('🔍 元素标签:', element.tagName);
            console.log('🔍 元素类名:', element.className);
            break;
          }
        }
      }

      // 策略2：通过位置查找（通常视频标签是第一个）
      if (!videoModeButton) {
        console.log('🔍 尝试通过位置查找视频标签...');

        // 查找包含"发布图文"的元素
        let imageElement = null;
        for (const element of allPossibleElements) {
          const elementText = element.textContent || element.innerText || '';
          if (elementText.includes('发布图文')) {
            imageElement = element;
            break;
          }
        }

        if (imageElement) {
          console.log('🔍 找到图文标签，查找相邻的视频标签...');

          // 查找同级的视频标签
          const parent = imageElement.parentElement;
          if (parent) {
            const siblings = parent.children;
            for (let i = 0; i < siblings.length; i++) {
              const sibling = siblings[i];
              const siblingText = sibling.textContent || sibling.innerText || '';
              if (siblingText.includes('发布视频') || siblingText.includes('视频')) {
                videoModeButton = sibling;
                console.log('✅ 通过位置关系找到视频标签:', siblingText);
                break;
              }
            }
          }
        }
      }

      // 策略3：通过容器结构查找
      if (!videoModeButton) {
        console.log('🔍 尝试通过容器结构查找...');

        // 查找包含多个标签的容器
        const containers = document.querySelectorAll('div, section, nav');
        for (const container of containers) {
          const containerText = container.textContent || container.innerText || '';
          if (containerText.includes('发布视频') && containerText.includes('发布图文')) {
            console.log('🔍 找到包含多个标签的容器');

            // 在容器中查找视频标签
            const videoElements = container.querySelectorAll('div, button, span');
            for (const element of videoElements) {
              const elementText = element.textContent || element.innerText || '';
              if (elementText.includes('发布视频') || elementText.includes('视频')) {
                videoModeButton = element;
                console.log('✅ 通过容器结构找到视频标签:', elementText);
                break;
              }
            }
            if (videoModeButton) break;
          }
        }
      }

      if (!videoModeButton) {
        console.log('⚠️ 未找到视频模式标签，可能已经是视频模式');
        return true;
      }

      console.log('✅ 找到视频模式标签，准备点击');
      console.log('🔍 标签文本:', videoModeButton.textContent);
      console.log('🔍 标签类型:', videoModeButton.tagName);
      console.log('🔍 标签类名:', videoModeButton.className);
      console.log('🔍 标签位置:', videoModeButton.getBoundingClientRect());

      videoModeButton.classList.add('content-filler-highlight');

      // 延时2秒后点击
      await this.delay(2);
      videoModeButton.click();

      // 点击后等待3秒让页面切换
      await this.delay(3);

      videoModeButton.classList.remove('content-filler-highlight');
      this.showStatus('✅ 已切换到视频发布模式');

      return true;
    } catch (error) {
      console.error('切换到视频发布模式失败:', error);
      this.showStatus('❌ 切换到视频发布模式失败');
      return false;
    }
  }

  // 执行所有内容填写流程
  async fillAllContent (contentData) {
    try {
      console.log('🚀 开始执行自动化内容填写流程...');
      this.showStatus('🚀 开始自动化内容填写...');

      // 等待页面完全加载
      await this.delay(3);

      // 第一步：点击高清发布按钮
      console.log('📋 步骤1: 点击高清发布按钮');
      const step1Result = await this.clickHighDefinitionPublish();
      if (!step1Result) {
        throw new Error('第一步失败：点击高清发布按钮');
      }

      // 步骤间延时
      await this.delay(4);

      // 第二步：根据内容类型选择发布模式
      if (contentData.content_type === 'image') {
        console.log('📋 步骤2: 切换到图文发布模式');
        const step2Result = await this.switchToImageMode();
        if (!step2Result) {
          throw new Error('第二步失败：切换到图文发布模式');
        }

        // 等待页面切换完成
        await this.delay(3);

        // 上传图片文件
        if (contentData.content_type === 'image') {
          console.log('📋 步骤2.1: 上传图片文件');
          const uploadResult = await this.uploadImage(contentData.file_path || contentData.file_url);
          if (!uploadResult) {
            throw new Error('图片上传失败');
          }

          // 等待上传完成
          await this.delay(3);
        }

      } else if (contentData.content_type === 'video') {
        console.log('📋 步骤2: 切换到视频发布模式');
        const step2Result = await this.switchToVideoMode();
        if (!step2Result) {
          throw new Error('第二步失败：切换到视频发布模式');
        }

        // 等待页面切换完成
        await this.delay(3);

        // 上传视频文件
        if (contentData.file_path || contentData.file_url) {
          console.log('📋 步骤2.1: 上传视频文件');
          const uploadResult = await this.uploadVideo(contentData.file_path || contentData.file_url);
          if (!uploadResult) {
            throw new Error('视频上传失败');
          }

          // 等待上传完成和页面导航
          console.log('📋 等待上传完成和页面导航...');
          await this.waitForPageNavigation();
          await this.waitForPageElements();

          // 上传完成后等待页面稳定
          await this.delay(5);
        }
      } else {
        console.log('⚠️ 未知的内容类型，使用默认视频模式');
        // 等待页面加载
        await this.delay(3);
      }

      // 步骤间延时
      await this.delay(4);

      // 第三步：填写标题
      if (contentData.title) {
        console.log('📋 步骤3: 填写标题');
        let title = contentData.title
        if (title.length > 20) {
          title = contentData.title.slice(0, 20)
        } else {
          title = contentData.title
        }
        const step3Result = await this.fillTitle(title);
        if (!step3Result) {
          throw new Error('第三步失败：填写标题');
        }

        // 步骤间延时
        await this.delay(4);
      }

      // 第四步：填写内容
      if (contentData.content) {
        console.log('📋 步骤4: 填写内容');
        const step4Result = await this.fillContent(contentData.content);
        if (!step4Result) {
          throw new Error('第四步失败：填写内容');
        }

        // 步骤间延时
        await this.delay(4);
      }

      // 第五步：填写标签
      if (contentData.tags) {
        console.log('📋 步骤5: 填写标签');
        const step5Result = await this.fillTags(contentData.tags);
        if (!step5Result) {
          throw new Error('第五步失败：填写标签');
        }

        // 步骤间延时
        await this.delay(4);
      }

      // 第六步：设置发布时间
      if (contentData.publish_time) {
        console.log('📋 步骤6: 设置发布时间');
        const step6Result = await this.setPublishTime(contentData.publish_time);
        if (!step6Result) {
          console.log('⚠️ 发布时间设置失败，继续执行');
        }

        // 步骤间延时
        await this.delay(3);
      }

      // 最终延时，让用户检查内容
      console.log('📋 所有内容填写完成，等待最终检查...');
      this.showStatus('✅ 所有内容填写完成，准备发布');
      await this.delay(5);

      // 第七步：点击发布按钮
      console.log('📋 步骤7: 点击发布按钮');
      const step7Result = await this.clickPublishButton();
      if (!step7Result) {
        throw new Error('第七步失败：点击发布按钮');
      }

      // 等待发布结果
      console.log('📋 等待发布结果...');
      this.showStatus('⏳ 等待发布结果...');
      await this.delay(10);

      // 检查发布是否成功
      // const publishSuccess = await this.checkPublishSuccess();
      const publishSuccess = true;
      if (publishSuccess) {
        console.log('🎉 发布成功！');
        this.showStatus('🎉 发布成功！');

        // 更新数据库状态为已发布
        await this.updatePublishStatus('published', contentData.id);

        // 发布成功后关闭窗口
        await this.closePublishWindow();

        return true;
      } else {
        console.log('❌ 发布可能失败');
        this.showStatus('❌ 发布可能失败');

        // 更新数据库状态为发布失败
        await this.updatePublishStatus('failed', contentData.id, '发布失败，请检查页面状态');

        // 发布失败后关闭窗口
        await this.closePublishWindow();

        return false;
      }

    } catch (error) {
      console.error('❌ 自动化内容填写流程失败:', error);
      this.showStatus(`❌ 自动化流程失败: ${error.message}`);

      // 更新数据库状态为失败
      if (contentData.id) {
        await this.updatePublishStatus('failed', contentData.id, error.message);
      }

      // 异常失败后关闭窗口
      await this.closePublishWindow();

      return false;
    }
  }

  // 检查发布是否成功
  async checkPublishSuccess () {
    try {
      console.log('🔍 检查发布结果...');

      // 等待一段时间让页面响应
      await this.delay(3);

      // 检查是否有成功提示或页面跳转
      const successIndicators = [
        // 成功提示文本 - 使用文本内容查找
        this.findElementByText(document.body, '发布成功'),
        this.findElementByText(document.body, '发布完成'),
        this.findElementByText(document.body, '已发布'),
        this.findElementByText(document.body, '发布成功'),
        // 成功图标或状态
        document.querySelector('.success-icon'),
        document.querySelector('.success-status'),
        document.querySelector('[class*="success"]'),
        // 页面URL变化
        window.location.href.includes('success') ||
        window.location.href.includes('complete') ||
        window.location.href.includes('published')
      ];

      // 检查是否有错误提示
      const errorIndicators = [
        this.findElementByText(document.body, '发布失败'),
        this.findElementByText(document.body, '发布错误'),
        document.querySelector('.error-message'),
        document.querySelector('[class*="error"]')
      ];

      // 如果有错误提示，返回失败
      for (const errorIndicator of errorIndicators) {
        if (errorIndicator) {
          console.log('❌ 检测到错误提示');
          return false;
        }
      }

      // 如果有成功提示，返回成功
      for (const successIndicator of successIndicators) {
        if (successIndicator) {
          console.log('✅ 检测到成功提示');
          return true;
        }
      }

      // 如果没有明确的成功或失败提示，检查页面状态
      console.log('⚠️ 未检测到明确的结果提示，检查页面状态...');

      // 检查是否还在发布页面
      if (window.location.href.includes('creator.douyin.com')) {
        console.log('📄 仍在发布页面，可能发布中...');
        return false;
      }

      // 如果页面已跳转，可能发布成功
      console.log('🔄 页面已跳转，可能发布成功');
      return true;

    } catch (error) {
      console.error('检查发布结果失败:', error);
      return false;
    }
  }

  // 更新发布状态到数据库
  async updatePublishStatus (status, recordId, errorMessage = null) {
    try {
      console.log(`📊 更新发布状态: ${status}, 记录ID: ${recordId}`);

      if (!recordId) {
        console.log('⚠️ 没有记录ID，跳过状态更新');
        return;
      }

      // 状态映射
      const statusMap = {
        'draft': '草稿',
        'processing': '处理中',
        'published': '已发布',
        'failed': '发布失败'
      };

      const statusData = {
        status: status,
        publish_time: this.publishTime ? this.publishTime : new Date().toLocaleString(),
        error_message: errorMessage,
        error_code: status === 'failed' ? 'PUBLISH_FAILED' : null
      };

      console.log(`📊 状态: ${status} (${statusMap[status]})`);
      console.log(`📊 状态数据:`, statusData);

      // 通过IPC调用更新数据库状态
      if (window.electronAPI && window.electronAPI.updatePublishRecordStatus) {
        try {
          const result = await window.electronAPI.updatePublishRecordStatus(recordId, statusData);
          if (result.success) {
            console.log('✅ 数据库状态更新成功');
          } else {
            console.error('❌ 数据库状态更新失败:', result.error);
          }
        } catch (error) {
          console.error('❌ 调用IPC接口失败:', error);
        }
      } else {
        console.log('⚠️ electronAPI不可用，无法更新数据库状态');
      }

    } catch (error) {
      console.error('更新发布状态失败:', error);
    }
  }

  // 关闭发布窗口
  async closePublishWindow () {
    try {
      console.log('🔻 请求关闭发布窗口...');
      
      // 通过IPC调用主进程关闭窗口
      if (window.electronAPI && window.electronAPI.closePublishWindow) {
        try {
          const result = await window.electronAPI.closePublishWindow();
          if (result.success) {
            console.log('✅ 发布窗口关闭请求已发送');
          } else {
            console.error('❌ 发布窗口关闭失败:', result.error);
          }
        } catch (error) {
          console.error('❌ 调用关闭窗口IPC接口失败:', error);
        }
      } else {
        console.log('⚠️ electronAPI不可用，无法关闭窗口');
        // 作为备选方案，尝试关闭当前窗口
        if (window.close) {
          window.close();
        }
      }

    } catch (error) {
      console.error('关闭发布窗口失败:', error);
    }
  }

  // 获取页面状态
  getPageStatus () {
    try {
      const status = {
        url: window.location.href,
        title: document.title,
        isPublishPage: window.location.href.includes('creator.douyin.com'),
        elements: {
          titleInput: !!document.querySelector('input[placeholder*="标题"], input[placeholder*="title"]'),
          contentInput: !!document.querySelector('textarea[placeholder*="内容"], textarea[placeholder*="描述"]'),
          uploadArea: !!document.querySelector('.container-drag-VAfIfu, .upload-area'),
          publishButton: !!document.querySelector('button:contains("发布")')
        }
      };

      return status;
    } catch (error) {
      console.error('获取页面状态失败:', error);
      return null;
    }
  }

  // 重置状态
  reset () {
    this.isInitialized = false;
    console.log('ContentFiller 状态已重置');
  }

  // 验证图片格式是否符合抖音要求
  validateImageForDouyin (imageFile) {
    try {
      console.log('🔍 验证图片格式是否符合抖音图文要求...');

      // 检查文件类型 - 根据HTML中的accept属性，抖音图文支持这些格式
      const supportedTypes = [
        'image/jpeg',
        'image/jpg',
        'image/png',
        'image/bmp',
        'image/webp',
        'image/tif',
        'image/tiff'
      ];

      if (!supportedTypes.includes(imageFile.type)) {
        console.log('❌ 不支持的图片格式:', imageFile.type, '(抖音图文支持的格式:', supportedTypes.join(', '), ')');
        return false;
      }

      // 检查文件大小（抖音通常限制在50MB以内）
      const maxSize = 50 * 1024 * 1024; // 50MB
      if (imageFile.size > maxSize) {
        console.log('❌ 图片文件过大:', imageFile.size, 'bytes, 最大允许:', maxSize, 'bytes');
        return false;
      }

      // 检查文件名
      if (imageFile.name.length > 100) {
        console.log('❌ 文件名过长:', imageFile.name.length, '字符, 最大允许: 100字符');
        return false;
      }

      // 检查文件名是否包含特殊字符
      const invalidChars = /[<>:"/\\|?*]/;
      if (invalidChars.test(imageFile.name)) {
        console.log('❌ 文件名包含特殊字符:', imageFile.name);
        return false;
      }

      console.log('✅ 图片格式验证通过');
      console.log('📊 验证结果:', {
        文件类型: imageFile.type,
        文件大小: imageFile.size + ' bytes',
        文件名: imageFile.name,
        最后修改: new Date(imageFile.lastModified).toLocaleString()
      });

      return true;
    } catch (error) {
      console.error('图片格式验证失败:', error);
      return false;
    }
  }

  // 转换图片为抖音支持的格式
  convertImageForDouyin (imageBlob, originalFileName) {
    try {
      console.log('🔄 转换图片为抖音图文支持的格式...');

      let finalFileName = originalFileName;
      let finalMimeType = imageBlob.type;

      // 根据MIME类型确定最佳格式 - 支持更多格式
      if (imageBlob.type.includes('jpeg') || imageBlob.type.includes('jpg')) {
        finalMimeType = 'image/jpeg';
        if (!finalFileName.endsWith('.jpg') && !finalFileName.endsWith('.jpeg')) {
          finalFileName = finalFileName.replace(/\.[^/.]+$/, '.jpg');
        }
      } else if (imageBlob.type.includes('png')) {
        finalMimeType = 'image/png';
        if (!finalFileName.endsWith('.png')) {
          finalFileName = finalFileName.replace(/\.[^/.]+$/, '.png');
        }
      } else if (imageBlob.type.includes('webp')) {
        finalMimeType = 'image/webp';
        if (!finalFileName.endsWith('.webp')) {
          finalFileName = finalFileName.replace(/\.[^/.]+$/, '.webp');
        }
      } else if (imageBlob.type.includes('bmp')) {
        finalMimeType = 'image/bmp';
        if (!finalFileName.endsWith('.bmp')) {
          finalFileName = finalFileName.replace(/\.[^/.]+$/, '.bmp');
        }
      } else if (imageBlob.type.includes('tif') || imageBlob.type.includes('tiff')) {
        finalMimeType = 'image/tiff';
        if (!finalFileName.endsWith('.tif') && !finalFileName.endsWith('.tiff')) {
          finalFileName = finalFileName.replace(/\.[^/.]+$/, '.tif');
        }
      } else if (imageBlob.type.includes('gif')) {
        // GIF格式不支持，强制转换为JPEG
        console.log('⚠️ 检测到GIF格式，抖音图文不支持，转换为JPEG...');
        finalMimeType = 'image/jpeg';
        finalFileName = finalFileName.replace(/\.[^/.]+$/, '.jpg');
      } else {
        // 默认转换为JPEG格式
        finalMimeType = 'image/jpeg';
        finalFileName = finalFileName.replace(/\.[^/.]+$/, '.jpg');
      }

      // 创建转换后的File对象
      const convertedFile = new File([imageBlob], finalFileName, {
        type: finalMimeType,
        lastModified: Date.now()
      });

      console.log('✅ 图片格式转换完成');
      console.log('📊 转换结果:', {
        原始文件名: originalFileName,
        最终文件名: finalFileName,
        原始MIME类型: imageBlob.type,
        最终MIME类型: finalMimeType,
        文件大小: convertedFile.size + ' bytes'
      });

      return convertedFile;
    } catch (error) {
      console.error('图片格式转换失败:', error);
      // 返回原始文件作为备选
      return new File([imageBlob], originalFileName, {
        type: imageBlob.type,
        lastModified: Date.now()
      });
    }
  }

  // 等待图片上传完成
  async waitForImageUploadComplete () {
    try {
      console.log('⏳ 等待图片上传完成...');
      this.showStatus('⏳ 等待图片上传完成...');

      // 等待上传进度条消失或上传完成提示出现
      const uploadCompleteSelectors = [
        // 上传完成提示
        '.upload-success',
        '.upload-complete',
        '.upload-done',
        '[class*="success"]',
        '[class*="complete"]',
        '[class*="done"]',
        // 上传进度条消失
        '.upload-progress:not(.visible)',
        '.progress-bar:not(.visible)',
        // 图片预览出现
        '.image-preview',
        '.uploaded-image',
        '[class*="preview"]',
        '[class*="uploaded"]',
        // 上传按钮状态变化
        'button:contains("重新上传")',
        'button:contains("删除")',
        // 页面URL变化（上传完成后会跳转）
        'body[data-upload-complete="true"]'
      ];

      // 等待上传完成
      const maxWaitTime = 60000; // 最多等待60秒
      const startTime = Date.now();

      while (Date.now() - startTime < maxWaitTime) {
        // 检查是否有上传完成提示
        for (const selector of uploadCompleteSelectors) {
          try {
            const element = document.querySelector(selector);
            if (element) {
              console.log('✅ 检测到上传完成提示:', selector);
              this.showStatus('✅ 图片上传完成');
              return true;
            }
          } catch (e) {
            // 忽略选择器错误
          }
        }

        // 检查页面URL是否变化（上传完成后通常会跳转）
        const currentUrl = window.location.href;
        if (currentUrl.includes('media_type=image') && currentUrl.includes('type=new')) {
          console.log('✅ 检测到页面已跳转到图文编辑页面');
          this.showStatus('✅ 图片上传完成，已跳转到编辑页面');
          return true;
        }

        // 检查是否有错误提示
        const errorSelectors = [
          '.upload-error',
          '.error-message',
          '[class*="error"]',
          'div:contains("上传失败")',
          'div:contains("格式不支持")'
        ];

        for (const selector of errorSelectors) {
          try {
            const element = document.querySelector(selector);
            if (element) {
              console.log('❌ 检测到上传错误:', selector, element.textContent);
              throw new Error(`图片上传失败: ${element.textContent}`);
            }
          } catch (e) {
            // 忽略选择器错误
          }
        }

        // 等待1秒后再次检查
        await this.delay(1);
        console.log('⏳ 继续等待图片上传完成...', Math.floor((Date.now() - startTime) / 1000), '秒');
      }

      // 超时处理
      console.log('⚠️ 等待图片上传完成超时');
      this.showStatus('⚠️ 图片上传可能已完成，继续下一步');
      return true;

    } catch (error) {
      console.error('等待图片上传完成失败:', error);
      this.showStatus('⚠️ 图片上传状态检查失败');
      return false;
    }
  }

  // 设置发布时间
  async setPublishTime (publishTime) {
    this.publishTime = publishTime
    try {
      console.log('⏰ 设置发布时间:', publishTime);
      this.showStatus('⏰ 设置发布时间...');

      // 等待页面加载完成
      await this.delay(2);

      // 第一步：查找并点击"定时发布"按钮
      console.log('🔍 第一步：查找定时发布按钮...');

      // 首先滚动到页面底部，确保定时发布按钮可见
      console.log('📜 滚动到页面底部查找定时发布按钮...');
      window.scrollTo(0, document.body.scrollHeight);
      await this.delay(1);

      // 根据提供的HTML结构，精确查找定时发布按钮
      let scheduledPublishButton = null;

      // 方法1：通过精确的class名查找所有相关按钮
      try {
        const allLabels = document.querySelectorAll('label.radio-d4zkru.one-line-o4_OmJ');
        console.log('🔍 找到所有radio按钮:', allLabels.length);

        for (const label of allLabels) {
          const labelText = label.textContent || label.innerText || '';
          console.log('🔍 检查按钮文本:', labelText);

          if (labelText.includes('定时发布')) {
            scheduledPublishButton = label;
            console.log('✅ 通过精确class名找到定时发布按钮');
            break;
          }
        }
      } catch (e) {
        console.log('⚠️ 精确class名查找失败:', e.message);
      }

      // 方法2：通过input的value属性查找
      if (!scheduledPublishButton) {
        try {
          // 查找所有checkbox，找到value="1"且包含"定时发布"文本的
          const allCheckboxes = document.querySelectorAll('input[type="checkbox"]');
          console.log('🔍 找到所有checkbox:', allCheckboxes.length);

          for (const checkbox of allCheckboxes) {
            const label = checkbox.closest('label');
            if (label) {
              const labelText = label.textContent || label.innerText || '';
              console.log('🔍 检查checkbox:', checkbox.value, '标签文本:', labelText);

              if (labelText.includes('定时发布')) {
                scheduledPublishButton = label;
                console.log('✅ 通过input value找到定时发布按钮');
                break;
              }
            }
          }
        } catch (e) {
          console.log('⚠️ input value查找失败:', e.message);
        }
      }

      // 方法3：通过文本内容查找（优先查找页面底部的元素）
      if (!scheduledPublishButton) {
        try {
          console.log('🔍 在页面底部区域查找定时发布按钮...');
          // 获取页面底部区域（最后20%的内容）
          const pageHeight = document.body.scrollHeight;
          const bottomArea = pageHeight * 0.8;

          const allElements = document.querySelectorAll('*');
          for (const element of allElements) {
            const elementText = element.textContent || element.innerText || '';
            // 确保包含"定时发布"但不包含"立即发布"
            if (elementText.includes('定时发布') &&
              elementText.includes('发布') &&
              !elementText.includes('立即发布')) {
              // 检查是否是label元素或包含input的元素
              if (element.tagName === 'LABEL' || element.querySelector('input')) {
                // 检查元素是否在页面底部
                const rect = element.getBoundingClientRect();
                const elementTop = rect.top + window.pageYOffset;

                if (elementTop > bottomArea) {
                  scheduledPublishButton = element;
                  console.log('✅ 在页面底部找到定时发布按钮:', element.tagName, element.className);
                  console.log('📍 元素位置:', elementTop, '页面高度:', pageHeight);
                  break;
                }
              }
            }
          }
        } catch (e) {
          console.log('⚠️ 文本内容查找失败:', e.message);
        }
      }

      // 方法4：通过class名模糊匹配查找
      if (!scheduledPublishButton) {
        try {
          const scheduleElements = document.querySelectorAll('.schedule-part-u9YG6e, .content-obt4oA');
          for (const element of scheduleElements) {
            if (element.textContent && element.textContent.includes('定时发布')) {
              scheduledPublishButton = element;
              console.log('✅ 通过class名模糊匹配找到定时发布区域');
              break;
            }
          }
        } catch (e) {
          console.log('⚠️ class名模糊匹配查找失败:', e.message);
        }
      }

      // 如果还是没找到，尝试滚动查找
      if (!scheduledPublishButton) {
        console.log('🔍 尝试滚动查找定时发布按钮...');

        // 从页面中间开始，逐步向下滚动查找
        const pageHeight = document.body.scrollHeight;
        const viewportHeight = window.innerHeight;
        const scrollSteps = 5;

        for (let i = 1; i <= scrollSteps; i++) {
          const scrollPosition = (pageHeight * i) / scrollSteps;
          window.scrollTo(0, scrollPosition);
          await this.delay(0.5);

          console.log(`🔍 第${i}次滚动，位置: ${scrollPosition}`);

          // 在当前视窗中查找
          const visibleElements = document.querySelectorAll('*');
          for (const element of visibleElements) {
            const elementText = element.textContent || element.innerText || '';
            // 确保包含"定时发布"但不包含"立即发布"
            if (elementText.includes('定时发布') &&
              elementText.includes('发布') &&
              !elementText.includes('立即发布')) {
              if (element.tagName === 'LABEL' || element.querySelector('input')) {
                const rect = element.getBoundingClientRect();
                if (rect.top >= 0 && rect.bottom <= viewportHeight) {
                  scheduledPublishButton = element;
                  console.log('✅ 通过滚动找到定时发布按钮:', element.tagName, element.className);
                  break;
                }
              }
            }
          }

          if (scheduledPublishButton) break;
        }
      }

      if (!scheduledPublishButton) {
        console.log('❌ 无法找到定时发布按钮');
        return false;
      }

      // 确保定时发布按钮完全可见
      console.log('📍 确保定时发布按钮完全可见...');
      try {
        const rect = scheduledPublishButton.getBoundingClientRect();
        const viewportHeight = window.innerHeight;

        // 如果按钮不在视窗中，滚动到按钮位置
        if (rect.top < 0 || rect.bottom > viewportHeight) {
          const scrollPosition = rect.top + window.pageYOffset - (viewportHeight / 2);
          window.scrollTo(0, scrollPosition);
          await this.delay(1);
          console.log('✅ 已滚动到定时发布按钮位置');
        }

        // 高亮显示找到的按钮
        scheduledPublishButton.style.border = '2px solid #FE2C55';
        scheduledPublishButton.style.boxShadow = '0 0 10px rgba(254, 44, 85, 0.5)';
        console.log('🎯 定时发布按钮已高亮显示');

        // 同时显示按钮文本，确保找到的是正确的按钮
        const buttonText = scheduledPublishButton.textContent || scheduledPublishButton.innerText || '';
        console.log('🎯 高亮的按钮文本:', buttonText);

        // 验证是否真的是"定时发布"按钮
        if (!buttonText.includes('定时发布') || buttonText.includes('立即发布')) {
          console.log('❌ 错误：找到的不是定时发布按钮！');
          console.log('❌ 按钮文本:', buttonText);
          return false;
        }

      } catch (e) {
        console.log('⚠️ 滚动到按钮位置失败:', e.message);
      }

      // 第二步：点击定时发布按钮
      console.log('🖱️ 第二步：点击定时发布按钮...');

      try {
        // 查找定时发布按钮内的input元素
        let checkboxInput = scheduledPublishButton.querySelector('input[type="checkbox"]');

        if (checkboxInput) {
          console.log('✅ 找到checkbox输入框:', checkboxInput);
          console.log('📊 checkbox当前状态:', checkboxInput.checked);

          // 确保checkbox被选中
          if (!checkboxInput.checked) {
            checkboxInput.checked = true;
            console.log('✅ 设置checkbox为选中状态');
          }

          // 触发change事件
          checkboxInput.dispatchEvent(new Event('change', { bubbles: true }));
          console.log('✅ 触发change事件成功');

          // 同时点击整个label元素，确保UI状态同步
          scheduledPublishButton.click();
          console.log('✅ 点击label元素成功');

        } else {
          console.log('⚠️ 未找到checkbox，尝试点击整个label');
          scheduledPublishButton.click();
          console.log('✅ 点击label元素成功');
        }

        // 等待页面响应
        await this.delay(2);

        // 验证checkbox状态
        if (checkboxInput) {
          console.log('📊 点击后checkbox状态:', checkboxInput.checked);
          if (checkboxInput.checked) {
            console.log('✅ checkbox状态设置成功');
          } else {
            console.log('⚠️ checkbox状态可能未正确设置');
          }
        }

      } catch (clickError) {
        console.log('⚠️ 点击定时发布按钮失败，尝试其他方法:', clickError.message);

        // 尝试模拟鼠标事件
        try {
          const mouseDownEvent = new MouseEvent('mousedown', {
            bubbles: true,
            cancelable: true,
            view: window
          });
          const mouseUpEvent = new MouseEvent('mouseup', {
            bubbles: true,
            cancelable: true,
            view: window
          });

          scheduledPublishButton.dispatchEvent(mouseDownEvent);
          scheduledPublishButton.dispatchEvent(mouseUpEvent);
          console.log('✅ 使用鼠标事件模拟点击成功');

          await this.delay(2);
        } catch (mouseError) {
          console.log('❌ 所有点击方法都失败:', mouseError.message);
          return false;
        }
      }

      // 第三步：查找并填写时间输入框
      console.log('🔍 第三步：查找时间输入框...');

      let timeInput = null;

      // 根据提供的HTML结构，精确查找时间输入框
      const timeInputSelectors = [
        // 精确匹配
        'input.semi-input.semi-input-default[format="yyyy-MM-dd HH:mm"]',
        'input[format="yyyy-MM-dd HH:mm"]',
        'input.semi-input[format*="yyyy-MM-dd"]',
        // 通过placeholder匹配
        'input[placeholder="日期和时间"]',
        'input[placeholder*="日期"]',
        'input[placeholder*="时间"]',
        // 通过class名匹配
        'input.semi-input',
        'input.semi-input-default',
        // 通过父容器匹配
        '.semi-input-wrapper input',
        '.semi-datepicker-input input'
      ];

      // 方法1：通过精确的format属性查找
      try {
        timeInput = document.querySelector('input[format="yyyy-MM-dd HH:mm"]');
        if (timeInput) {
          console.log('✅ 通过精确format属性找到时间输入框');
        }
      } catch (e) {
        console.log('⚠️ 精确format属性查找失败:', e.message);
      }

      // 方法2：通过精确的class名查找
      if (!timeInput) {
        try {
          timeInput = document.querySelector('input.semi-input.semi-input-default');
          if (timeInput) {
            console.log('✅ 通过精确class名找到时间输入框');
          }
        } catch (e) {
          console.log('⚠️ 精确class名查找失败:', e.message);
        }
      }

      // 方法3：通过placeholder查找
      if (!timeInput) {
        try {
          timeInput = document.querySelector('input[placeholder="日期和时间"]');
          if (timeInput) {
            console.log('✅ 通过placeholder找到时间输入框');
          }
        } catch (e) {
          console.log('⚠️ placeholder查找失败:', e.message);
        }
      }

      // 方法4：在定时发布按钮的父级容器中查找
      if (!timeInput) {
        try {
          let parentContainer = scheduledPublishButton.parentElement;
          for (let i = 0; i < 3; i++) {
            if (parentContainer) {
              console.log(`🔍 在第${i + 1}级父容器中查找时间输入框...`);
              for (const selector of timeInputSelectors) {
                try {
                  timeInput = parentContainer.querySelector(selector);
                  if (timeInput) {
                    console.log('✅ 在父级容器中找到时间输入框:', selector);
                    break;
                  }
                } catch (e) {
                  console.log('⚠️ 选择器查找失败:', selector, e.message);
                }
              }
              if (timeInput) break;
              parentContainer = parentContainer.parentElement;
            }
          }
        } catch (e) {
          console.log('⚠️ 父级容器查找失败:', e.message);
        }
      }

      // 方法5：通过父容器class名查找
      if (!timeInput) {
        try {
          const wrapper = document.querySelector('.semi-input-wrapper');
          if (wrapper) {
            timeInput = wrapper.querySelector('input');
            if (timeInput) {
              console.log('✅ 通过父容器class名找到时间输入框');
            }
          }
        } catch (e) {
          console.log('⚠️ 父容器class名查找失败:', e.message);
        }
      }

      // 方法6：在整个页面查找
      if (!timeInput) {
        console.log('🔍 在整个页面查找时间输入框...');
        for (const selector of timeInputSelectors) {
          try {
            timeInput = document.querySelector(selector);
            if (timeInput) {
              console.log('✅ 在整个页面找到时间输入框:', selector);
              break;
            }
          } catch (e) {
            console.log('⚠️ 时间输入框查找失败:', selector, e.message);
          }
        }
      }

      if (!timeInput) {
        console.log('❌ 未找到时间输入框');
        return false;
      }

      // 第四步：设置发布时间
      console.log('📅 第四步：设置发布时间:', publishTime);

      // 抖音需要的格式不需要转换 (yyyy-MM-dd HH:mm)

      console.log('📅 格式化后的时间:', publishTime);
      console.log('📅 时间输入框类型:', timeInput.type);
      console.log('📅 时间输入框class:', timeInput.className);
      console.log('📅 时间输入框format属性:', timeInput.getAttribute('format'));

      // 方法1：使用Object.defineProperty
      try {
        console.log('🔄 尝试方法2：使用Object.defineProperty...');
        Object.defineProperty(timeInput, 'value', {
          value: publishTime,
          writable: true,
          configurable: true
        });
        timeInput.dispatchEvent(new Event('input', { bubbles: true }));
        timeInput.dispatchEvent(new Event('change', { bubbles: true }));
        console.log('✅ 使用Object.defineProperty设置时间成功');
      } catch (e2) {
        console.log('⚠️ Object.defineProperty方法也失败:', e2.message);

        // 方法3：模拟用户输入
        try {
          console.log('🔄 尝试方法3：模拟用户输入...');
          timeInput.focus();
          timeInput.select();
          document.execCommand('insertText', false, publishTime);
          timeInput.dispatchEvent(new Event('input', { bubbles: true }));
          timeInput.dispatchEvent(new Event('change', { bubbles: true }));
          console.log('✅ 使用execCommand设置时间成功');
        } catch (e3) {
          console.log('❌ 所有时间设置方法都失败:', e3.message);

          // 方法4：尝试触发点击事件打开日期选择器
          try {
            console.log('🔄 尝试方法4：触发日期选择器...');
            timeInput.click();
            await this.delay(1);
            timeInput.value = publishTime;
            timeInput.dispatchEvent(new Event('input', { bubbles: true }));
            timeInput.dispatchEvent(new Event('change', { bubbles: true }));
            console.log('✅ 通过触发日期选择器设置时间成功');
          } catch (e4) {
            console.log('❌ 所有时间设置方法都失败:', e4.message);
            return false;
          }
        }
      }

      // 验证时间是否设置成功
      await this.delay(2);
      console.log('🔍 验证时间设置结果...');
      console.log('📅 期望时间:', publishTime);
      console.log('📅 实际时间:', timeInput.value);
      console.log('📅 时间输入框当前状态:', {
        value: timeInput.value,
        placeholder: timeInput.placeholder,
        disabled: timeInput.disabled,
        readonly: timeInput.readOnly
      });

      // 验证时间设置是否成功
      let timeSetSuccess = false;

      // 检查1：完全匹配
      if (timeInput.value === publishTime) {
        console.log('✅ 时间完全匹配');
        timeSetSuccess = true;
      }
      // 检查2：包含日期部分
      else if (timeInput.value.includes(publishTime.split(' ')[0])) {
        console.log('✅ 时间日期部分匹配');
        timeSetSuccess = true;
      }
      // 检查3：包含时间部分
      else if (timeInput.value.includes(publishTime.split(' ')[1])) {
        console.log('✅ 时间时间部分匹配');
        timeSetSuccess = true;
      }
      // 检查4：格式相似（可能有时区差异）
      else if (timeInput.value.match(/\d{4}-\d{2}-\d{2}/) && timeInput.value.match(/\d{2}:\d{2}/)) {
        console.log('✅ 时间格式匹配（可能有时区差异）');
        timeSetSuccess = true;
      }
      // 检查5：输入框有值且不是原始值
      else if (timeInput.value && timeInput.value !== timeInput.placeholder) {
        console.log('✅ 时间输入框有值且已改变');
        timeSetSuccess = true;
      }

      if (timeSetSuccess) {
        console.log('✅ 发布时间设置成功');
        this.showStatus('✅ 发布时间设置成功');
        return true;
      } else {
        console.log('⚠️ 时间设置可能失败，当前值:', timeInput.value);
        console.log('⚠️ 建议检查时间格式或手动验证');
        this.showStatus('⚠️ 时间设置可能失败，请检查');
        return false;
      }

    } catch (error) {
      console.error('设置发布时间失败:', error);
      this.showStatus('❌ 设置发布时间失败');
      return false;
    }
  }
}

// 创建全局实例
window.contentFiller = new ContentFiller();

// 导出类（如果支持模块系统）
if (typeof module !== 'undefined' && module.exports) {
  module.exports = ContentFiller;
} 